• Programming
• A-Level
• GCSE
• KS3
• Home

Home KS3 GCSE A-Level Programming

Lesson 4. Information Encoding Systems

Lesson Notes

Bit Patterns

Bit patterns play a crucial role in representing various types of data. Whether it's text, images, sound, or integers, everything is ultimately translated into binary form-combinations of 1s and 0s. Let's explore how different data types are converted into these bit patterns:

Text (Characters):

When you press a key on your keyboard, it needs to be transformed into a binary number so that the computer can process it and display the corresponding character on the screen.

The ASCII code (American Standard Code for Information Interchange) assigns a unique binary number to each character. For instance:

• The letter 'a' corresponds to the binary number 0110 0001 (decimal 97).
• The letter 'b' corresponds to 0110 0010 (decimal 98).
• The letter 'c' corresponds to 0110 0011 (decimal 99).

ASCII code covers special characters, punctuation, return keys, control characters, as well as uppercase and lowercase letters. It can represent 128 characters, which suffices for most English words but falls short for other languages.

Images:

Images are typically represented as bitmap graphics. Each image consists of tiny squares called pixels.

The color of each pixel is encoded using binary values. For example:

• Black pixel: 00000000 (no color)
• White pixel: 11111111 (full color)

Additionally, the color depth determines the range of colors an image can display. Higher color depth allows more vibrant and detailed images.

Sound:

Sound is captured through sampling. Analog sound waves are converted into digital samples.

The bit depth (number of bits per sample) affects sound quality. More bits provide greater accuracy.

Common audio formats (like MP3) use bit patterns to represent sound data.

Here some practical examples of file sizes:

• One Character File: A single character (e.g., 'a') occupies 1 byte.
• Full Page of Text: Approximately 30 kilobytes (kB). That's the size of a typical text document.
• DVD: Approximately 4.5 gigabytes (GB). DVDs store movies, software, or large data files
• Hard Disk: A whopping 1 terabyte (TB). Modern hard drives offer massive storage capacity for files, applications, and more.
• Small Digital Color Photograph: Roughly 3 megabytes (MB). This size accommodates a decent-quality photo.
• Music CD: About 600 MB. A standard audio CD holds around 74 minutes of music.

Storage Prefix

Computers process and store large amounts of bytes, often in the order millions or billions.

When dealing with large quantities it is more convenient to summarise this using number prefixes.

A common example of this is the kilogram (kg) which is equivalent to 1000 grams (g).

When describing quantities of bytes we use either: Binary prefixes (powers of 2) or decimal prefixes (powers of 10).

The same number prefixes for decimal values can be used to summarise large quantities of bytes.

Common prefixes include:

• kilobyte (kB) = 10³ = 1,000
• megabyte (MB) = 10⁶ = 1,000,000
• gigabyte (GB) = 10⁹ = 1,000,000,000
• terabyte (TB) = 10¹² = 1,000,000,000,000

Traditionally computer scientists used these same number prefixes to refer to groups of bytes.

These are not the same as their decimal equivalents.

EXAMPLE???

To eliminate this confusion, in 1998 the International Electrotechnical Commission (IEC) established different prefixes to represent multiples of base 2:

• kibibyte (KiB) = 2¹⁰ = 1,024
• mebibyte (MiB) = 2²⁰ = 1,048,576
• gibibyte (GiB) = 2³⁰ = 1,073,741,824
• tebibyte (TiB) = 2⁴⁰ = 1,099,511,627,776

Storage devices used binary base 2 numbers, so binary prefix is more accurate.

Units of Measurement

In the metric system, we have straightforward conversions: 1 kilometer (km) equals 1000 meters (m), and 1 kilogram (kg) equals 1000 grams (g). These powers of 10 make sense and are easy to remember.

However, when it comes to digital storage, things get interesting. Computers use binary (base 2) for everything. So, when they measure storage, they work in powers of 2. A kilobyte (kB) is commonly understood to be 1000 bytes. However, there's a historical twist.

In binary terms, a kilobyte is actually 1024 bytes (2¹⁰). This discrepancy arises because 1024 is the nearest power of 2 that's close to 1000. To address this, modern terminology introduces the concept of a kibibyte (KiB). A kibibyte is precisely 1024 bytes, matching the binary reality. Meanwhile, a kilobyte (kB) remains 1000 bytes (as per the metric system).

Binary patterns can be used to represent any data, be it text, sound, images or video. The number of possible bit combinations or patterns available increase with when the numbers of bits increase.

Lesson Notes

        _,.--.
      .'      `-.
     /   O O   \
    |          /
    |         /
    |        /
     \      /
      `.__.'
    

        /\_/\
       ( o.o )
      > ^ <
     /  ---  \
    /         \
   /           \
  

        /\
        /  \
       / o o \
      /   ^   \
     /         \
    /_/-\___\_\
    

        ,--./,-.
        / #      \
       |          |
        \        / 
         `._,._,'
    

How to work out file size of text...

number of characters x bits used to represent each character = file size in bits

Let's work out the file size of the phrase: Social Distancing

• 17 characters x 7 bit ASCII = 119 bits
• 17 characters x 8 bit ASCII = 136 bits
• 17 characters x 16 bit Unicode = 272 bits